home *** CD-ROM | disk | FTP | other *** search
/ Freelog 121 / FreelogMagazineJuilletAout2014-No121.iso / Outils / Adobe-Air / adobe-air_13.exe / [0] / setup.swf / scripts / mx / effects / Tween.as < prev    next >
Text File  |  2014-03-27  |  10KB  |  345 lines
  1. package mx.effects
  2. {
  3.    import flash.events.EventDispatcher;
  4.    import flash.events.TimerEvent;
  5.    import flash.utils.Timer;
  6.    import flash.utils.getTimer;
  7.    import mx.core.UIComponentGlobals;
  8.    import mx.core.mx_internal;
  9.    import mx.events.TweenEvent;
  10.    
  11.    use namespace mx_internal;
  12.    
  13.    public class Tween extends EventDispatcher
  14.    {
  15.       
  16.       private static var timer:Timer = null;
  17.       
  18.       private static var interval:Number = 10;
  19.       
  20.       mx_internal static var activeTweens:Array = [];
  21.       
  22.       mx_internal static var intervalTime:Number = NaN;
  23.       
  24.       mx_internal static const VERSION:String = "3.0.0.0";
  25.        
  26.       
  27.       private var started:Boolean = false;
  28.       
  29.       private var previousUpdateTime:Number;
  30.       
  31.       public var duration:Number = 3000;
  32.       
  33.       private var id:int;
  34.       
  35.       private var arrayMode:Boolean;
  36.       
  37.       private var _isPlaying:Boolean = true;
  38.       
  39.       private var startValue:Object;
  40.       
  41.       public var listener:Object;
  42.       
  43.       private var userEquation:Function;
  44.       
  45.       mx_internal var needToLayout:Boolean = false;
  46.       
  47.       private var updateFunction:Function;
  48.       
  49.       private var _doSeek:Boolean = false;
  50.       
  51.       mx_internal var startTime:Number;
  52.       
  53.       private var endFunction:Function;
  54.       
  55.       private var endValue:Object;
  56.       
  57.       private var _doReverse:Boolean = false;
  58.       
  59.       private var _playheadTime:Number = 0;
  60.       
  61.       private var _invertValues:Boolean = false;
  62.       
  63.       private var maxDelay:Number = 87.5;
  64.       
  65.       public function Tween(param1:Object, param2:Object, param3:Object, param4:Number = -1, param5:Number = -1, param6:Function = null, param7:Function = null)
  66.       {
  67.          userEquation = defaultEasingFunction;
  68.          super();
  69.          if(!param1)
  70.          {
  71.             return;
  72.          }
  73.          if(param2 is Array)
  74.          {
  75.             arrayMode = true;
  76.          }
  77.          this.listener = param1;
  78.          this.startValue = param2;
  79.          this.endValue = param3;
  80.          if(!isNaN(param4) && param4 != -1)
  81.          {
  82.             this.duration = param4;
  83.          }
  84.          if(!isNaN(param5) && param5 != -1)
  85.          {
  86.             maxDelay = 1000 / param5;
  87.          }
  88.          this.updateFunction = param6;
  89.          this.endFunction = param7;
  90.          if(param4 == 0)
  91.          {
  92.             id = -1;
  93.             endTween();
  94.          }
  95.          else
  96.          {
  97.             Tween.addTween(this);
  98.          }
  99.       }
  100.       
  101.       mx_internal static function removeTween(param1:Tween) : void
  102.       {
  103.          removeTweenAt(param1.id);
  104.       }
  105.       
  106.       private static function addTween(param1:Tween) : void
  107.       {
  108.          param1.id = mx_internal::activeTweens.length;
  109.          mx_internal::activeTweens.push(param1);
  110.          if(!timer)
  111.          {
  112.             timer = new Timer(interval);
  113.             timer.addEventListener(TimerEvent.TIMER,timerHandler);
  114.             timer.start();
  115.          }
  116.          else
  117.          {
  118.             timer.start();
  119.          }
  120.          if(isNaN(mx_internal::intervalTime))
  121.          {
  122.             intervalTime = getTimer();
  123.          }
  124.          param1.startTime = param1.previousUpdateTime = mx_internal::intervalTime;
  125.       }
  126.       
  127.       private static function timerHandler(param1:TimerEvent) : void
  128.       {
  129.          var _loc6_:Tween = null;
  130.          var _loc2_:Boolean = false;
  131.          var _loc3_:Number = mx_internal::intervalTime;
  132.          intervalTime = getTimer();
  133.          var _loc4_:int;
  134.          var _loc5_:int = _loc4_ = mx_internal::activeTweens.length;
  135.          while(_loc5_ >= 0)
  136.          {
  137.             if(_loc6_ = Tween(mx_internal::activeTweens[_loc5_]))
  138.             {
  139.                _loc6_.needToLayout = false;
  140.                _loc6_.doInterval();
  141.                if(_loc6_.needToLayout)
  142.                {
  143.                   _loc2_ = true;
  144.                }
  145.             }
  146.             _loc5_--;
  147.          }
  148.          if(_loc2_)
  149.          {
  150.             UIComponentGlobals.layoutManager.validateNow();
  151.          }
  152.          param1.updateAfterEvent();
  153.       }
  154.       
  155.       private static function removeTweenAt(param1:int) : void
  156.       {
  157.          var _loc4_:Tween = null;
  158.          if(param1 >= mx_internal::activeTweens.length || param1 < 0)
  159.          {
  160.             return;
  161.          }
  162.          mx_internal::activeTweens.splice(param1,1);
  163.          var _loc2_:int = mx_internal::activeTweens.length;
  164.          var _loc3_:int = param1;
  165.          while(_loc3_ < _loc2_)
  166.          {
  167.             --(_loc4_ = Tween(mx_internal::activeTweens[_loc3_])).id;
  168.             _loc3_++;
  169.          }
  170.          if(_loc2_ == 0)
  171.          {
  172.             intervalTime = NaN;
  173.             timer.reset();
  174.          }
  175.       }
  176.       
  177.       mx_internal function get playheadTime() : Number
  178.       {
  179.          return _playheadTime;
  180.       }
  181.       
  182.       public function stop() : void
  183.       {
  184.          if(id >= 0)
  185.          {
  186.             Tween.removeTweenAt(id);
  187.          }
  188.       }
  189.       
  190.       mx_internal function get playReversed() : Boolean
  191.       {
  192.          return _invertValues;
  193.       }
  194.       
  195.       mx_internal function set playReversed(param1:Boolean) : void
  196.       {
  197.          _invertValues = param1;
  198.       }
  199.       
  200.       public function resume() : void
  201.       {
  202.          _isPlaying = true;
  203.          startTime = mx_internal::intervalTime - _playheadTime;
  204.          if(_doReverse)
  205.          {
  206.             reverse();
  207.             _doReverse = false;
  208.          }
  209.       }
  210.       
  211.       public function setTweenHandlers(param1:Function, param2:Function) : void
  212.       {
  213.          this.updateFunction = param1;
  214.          this.endFunction = param2;
  215.       }
  216.       
  217.       private function defaultEasingFunction(param1:Number, param2:Number, param3:Number, param4:Number) : Number
  218.       {
  219.          return param3 / 2 * (Math.sin(Math.PI * (param1 / param4 - 0.5)) + 1) + param2;
  220.       }
  221.       
  222.       public function set easingFunction(param1:Function) : void
  223.       {
  224.          userEquation = param1;
  225.       }
  226.       
  227.       public function endTween() : void
  228.       {
  229.          var _loc1_:TweenEvent = new TweenEvent(TweenEvent.TWEEN_END);
  230.          var _loc2_:Object = getCurrentValue(duration);
  231.          _loc1_.value = _loc2_;
  232.          dispatchEvent(_loc1_);
  233.          if(endFunction != null)
  234.          {
  235.             endFunction(_loc2_);
  236.          }
  237.          else
  238.          {
  239.             listener.onTweenEnd(_loc2_);
  240.          }
  241.          if(id >= 0)
  242.          {
  243.             Tween.removeTweenAt(id);
  244.          }
  245.       }
  246.       
  247.       public function reverse() : void
  248.       {
  249.          if(_isPlaying)
  250.          {
  251.             _doReverse = false;
  252.             seek(duration - _playheadTime);
  253.             _invertValues = !_invertValues;
  254.          }
  255.          else
  256.          {
  257.             _doReverse = !_doReverse;
  258.          }
  259.       }
  260.       
  261.       mx_internal function getCurrentValue(param1:Number) : Object
  262.       {
  263.          var _loc2_:Array = null;
  264.          var _loc3_:int = 0;
  265.          var _loc4_:int = 0;
  266.          if(duration == 0)
  267.          {
  268.             return endValue;
  269.          }
  270.          if(_invertValues)
  271.          {
  272.             param1 = duration - param1;
  273.          }
  274.          if(arrayMode)
  275.          {
  276.             _loc2_ = [];
  277.             _loc3_ = startValue.length;
  278.             _loc4_ = 0;
  279.             while(_loc4_ < _loc3_)
  280.             {
  281.                _loc2_[_loc4_] = userEquation(param1,startValue[_loc4_],endValue[_loc4_] - startValue[_loc4_],duration);
  282.                _loc4_++;
  283.             }
  284.             return _loc2_;
  285.          }
  286.          return userEquation(param1,startValue,Number(endValue) - Number(startValue),duration);
  287.       }
  288.       
  289.       mx_internal function doInterval() : Boolean
  290.       {
  291.          var _loc2_:Number = NaN;
  292.          var _loc3_:Object = null;
  293.          var _loc4_:TweenEvent = null;
  294.          var _loc5_:TweenEvent = null;
  295.          var _loc1_:Boolean = false;
  296.          previousUpdateTime = mx_internal::intervalTime;
  297.          if(_isPlaying || _doSeek)
  298.          {
  299.             _loc2_ = mx_internal::intervalTime - mx_internal::startTime;
  300.             _playheadTime = _loc2_;
  301.             _loc3_ = getCurrentValue(_loc2_);
  302.             if(_loc2_ >= duration && !_doSeek)
  303.             {
  304.                endTween();
  305.                _loc1_ = true;
  306.             }
  307.             else
  308.             {
  309.                if(!started)
  310.                {
  311.                   _loc5_ = new TweenEvent(TweenEvent.TWEEN_START);
  312.                   dispatchEvent(_loc5_);
  313.                   started = true;
  314.                }
  315.                (_loc4_ = new TweenEvent(TweenEvent.TWEEN_UPDATE)).value = _loc3_;
  316.                dispatchEvent(_loc4_);
  317.                if(updateFunction != null)
  318.                {
  319.                   updateFunction(_loc3_);
  320.                }
  321.                else
  322.                {
  323.                   listener.onTweenUpdate(_loc3_);
  324.                }
  325.             }
  326.             _doSeek = false;
  327.          }
  328.          return _loc1_;
  329.       }
  330.       
  331.       public function pause() : void
  332.       {
  333.          _isPlaying = false;
  334.       }
  335.       
  336.       public function seek(param1:Number) : void
  337.       {
  338.          var _loc2_:Number = mx_internal::intervalTime;
  339.          previousUpdateTime = _loc2_;
  340.          startTime = _loc2_ - param1;
  341.          _doSeek = true;
  342.       }
  343.    }
  344. }
  345.